package com.liusr.common.result;

/**
 * @author Liusr
 * @date 2023/1/22
 * @package com.liusr.common.result
 * @Description: 统一返回格式响应方法
 */
public class ResultData {
	/**
	 * 操作成功【增删改】
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> ok() {
		return common(ResultEnum.OK.getCode(), ResultEnum.OK.getMsg(), null);
	}

	/**
	 * 操作成功，自定义响应信息【增删改】
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> ok(String msg) {
		return common(ResultEnum.OK.getCode(), msg, null);
	}

	/**
	 * 操作成功，携带响应对象【增删改】
	 *
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> ok(T data) {
		return common(ResultEnum.OK.getCode(), ResultEnum.OK.getMsg(), data);
	}

	/**
	 * 操作成功，自定义响应信息和响应对象【增删改】
	 *
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> ok(String msg, T data) {
		return common(ResultEnum.OK.getCode(), msg, data);
	}

	/**
	 * 操作失败【增删改】
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> noOk() {
		return common(ResultEnum.NO_OK.getCode(), ResultEnum.NO_OK.getMsg(), null);
	}

	/**
	 * 操作失败，自定义响应信息【增删改】
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> noOk(String msg) {
		return common(ResultEnum.NO_OK.getCode(), msg, null);
	}

	/**
	 * 操作失败，携带响应对象【增删改】
	 *
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> noOk(T data) {
		return common(ResultEnum.NO_OK.getCode(), ResultEnum.NO_OK.getMsg(), data);
	}

	/**
	 * 操作失败，自定义响应信息和响应对象【增删改】
	 *
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> noOk(String msg, T data) {
		return common(ResultEnum.NO_OK.getCode(), msg, data);
	}

	/**
	 * 请求成功【查询】
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> success() {
		return common(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg(), null);
	}

	/**
	 * 请求成功，自定义响应信息【查询】
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> success(String msg) {
		return common(ResultEnum.SUCCESS.getCode(), msg, null);
	}

	/**
	 * 请求成功，携带响应对象【查询】
	 *
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> success(T data) {
		return common(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg(), data);
	}

	/**
	 * 请求成功，自定义响应信息和响应对象【查询】
	 *
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> success(String msg, T data) {
		return common(ResultEnum.SUCCESS.getCode(), msg, data);
	}

	/**
	 * 请求失败
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> fail() {
		return common(ResultEnum.FAIL.getCode(), ResultEnum.FAIL.getMsg(), null);
	}

	/**
	 * 请求失败，自定义响应信息
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> fail(String msg) {
		return common(ResultEnum.FAIL.getCode(), msg, null);
	}

	/**
	 * 请求失败，携带响应对象
	 *
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> fail(T data) {
		return common(ResultEnum.FAIL.getCode(), ResultEnum.FAIL.getMsg(), data);
	}

	/**
	 * 请求失败，自定义响应信息和响应对象
	 *
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> fail(String msg, T data) {
		return common(ResultEnum.FAIL.getCode(), msg, data);
	}

	/**
	 * 响应成功
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> respSuccess() {
		return common(ResultEnum.RESPONSE_SUCCESS.getCode(), ResultEnum.RESPONSE_SUCCESS.getMsg(), null);
	}

	/**
	 * 响应成功，自定义响应信息
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> respSuccess(String msg) {
		return common(ResultEnum.RESPONSE_SUCCESS.getCode(), msg, null);
	}

	/**
	 * 响应成功，携带响应对象
	 *
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> respSuccess(T data) {
		return common(ResultEnum.RESPONSE_SUCCESS.getCode(), ResultEnum.RESPONSE_SUCCESS.getMsg(), data);
	}

	/**
	 * 响应成功，自定义响应信息和响应对象
	 *
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> respSuccess(String msg, T data) {
		return common(ResultEnum.RESPONSE_SUCCESS.getCode(), msg, data);
	}

	/**
	 * 响应失败
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> respFailed() {
		return common(ResultEnum.RESPONSE_FAILED.getCode(), ResultEnum.RESPONSE_FAILED.getMsg(), null);
	}

	/**
	 * 响应失败，自定义响应信息
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> respFailed(String msg) {
		return common(ResultEnum.RESPONSE_FAILED.getCode(), msg, null);
	}

	/**
	 * 响应失败，携带响应对象
	 *
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> respFailed(T data) {
		return common(ResultEnum.RESPONSE_FAILED.getCode(), ResultEnum.RESPONSE_FAILED.getMsg(), data);
	}

	/**
	 * 响应失败，自定义响应信息和响应对象
	 *
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> respFailed(String msg, T data) {
		return common(ResultEnum.RESPONSE_FAILED.getCode(), msg, data);
	}

	/**
	 * 权限不足
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> noPermission() {
		return common(ResultEnum.NO_PERMISSION.getCode(), ResultEnum.NO_PERMISSION.getMsg(), null);
	}

	/**
	 * 客户端错误
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> clientError() {
		return common(ResultEnum.CLIENT_ERROR.getCode(), ResultEnum.CLIENT_ERROR.getMsg(), null);
	}

	/**
	 * 服务器错误
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> serverError() {
		return common(ResultEnum.SERVER_ERROR.getCode(), ResultEnum.SERVER_ERROR.getMsg(), null);
	}

	/**
	 * 服务器错误
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result<T>
	 */
	public static <T> Result<T> serverError(String msg) {
		return common(ResultEnum.SERVER_ERROR.getCode(), msg, null);
	}

	/**
	 * 未知错误
	 *
	 * @param <T> T
	 * @return Result
	 */
	public static <T> Result<T> unKnowError() {
		return common(ResultEnum.UNKNOWN_ERROR.getCode(), ResultEnum.UNKNOWN_ERROR.getMsg(), null);
	}

	/**
	 * 未知错误
	 *
	 * @param msg 响应信息
	 * @param <T> T
	 * @return Result<T>
	 */
	public static <T> Result<T> unKnowError(String msg) {
		return common(ResultEnum.UNKNOWN_ERROR.getCode(), msg, null);
	}

	/**
	 * 自定义响应格式
	 *
	 * @param code 响应码
	 * @param msg  响应信息
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> customResp(Integer code, String msg) {
		return common(code, msg, null);
	}

	/**
	 * 自定义响应格式
	 *
	 * @param code 响应码
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	public static <T> Result<T> customResp(Integer code, String msg, T data) {
		return common(code, msg, data);
	}

	/**
	 * 公共响应方法
	 *
	 * @param code 响应码
	 * @param msg  响应信息
	 * @param data 响应对象
	 * @param <T>  T
	 * @return Result
	 */
	private static <T> Result<T> common(Integer code, String msg, T data) {
		Result<T> result = new Result<>();
		result.setCode(code);
		result.setMsg(msg);
		result.setData(data);
		return result;
	}
}
